 $(function($) {



     var listdata = [];

     var treeGridData = [];

     var measureType = ["yx", "yc", "yk", "yt"];
     $("#comit").off().on("click", function() {
         var data = {};
         $.each(measureType, function(index, type) {

             var table = $('#measure_' + type);
             var rowdata = table.data("rowData");
             if (rowdata) {
                 data[type] = rowdata;

                 table.removeData("rowData");
             }
         });
         var value = JSON.stringify(data);
         alert(value);
     });

     $("#export").off().on("click", function() {
         // //alert("gen");
         // var val =
         // JSON.stringify($("#property_item_body").componentProperty('values'));
         // alert(val);
         // if ($('#measure_tab').data("rowData")) {
         // var value = JSON.stringify($('#measure_tab').data("rowData"));
         // //获取数值之后移除数据项
         // $('#measure_tab').removeData("rowData");
         // }
         $.config.prompt(function(dlg) {
             alert(dlg.value);
         })

     });
     // opc和modbus调用单独的配置文件，和数据文件。因为配置项与其他规约不一样
    
     if (gPageParam.processPage.driverName.toLowerCase().indexOf("opc") > -1) {
         gPageParam.processPage.driverName = "opc";
     } else if (gPageParam.processPage.driverName.toLowerCase().indexOf("modbus") > -1) {
         gPageParam.processPage.driverName = "modbus";
     } else {
         gPageParam.processPage.driverName = "";
     }

     // //////////////////////////////////////////////////
     $('#measureTabs').jqxTabs({
         width: '99.5%',
         height: '99.5%',
         theme: theme,
         collapsible: true,
         initTabContent: function(tab) {
             // The 'tab' parameter represents the selected tab's index.

             initPropertyGrid(tab, gPageParam.processPage.driverName);
             // var pageIndex = tab + 1;
             // loadPage('pages/ajax' + pageIndex + '.htm', pageIndex);
         }

     }).on('tabclick', function(event) {
         var tabclicked = event.args.item;
         currentTable = "#process_" + tableid[tabclicked];
         // alert('The clicked tab is ' + tabclicked);
         // alert( event.args.target );
     });

     // initPropertyGrid("yc", "");
     // initPropertyGrid("yx", "");
     // initPropertyGrid("yk", "");
     // initPropertyGrid("yt", "");


     initToolBar();
     // 初始化，系统量测选择对话框
     var measureSysDlg = initMeasureSysDlg();

     // 表格显示需要的数据 *Type 为显示dropdownlist需要的数据
     var gridProperty = {
         yc: {
             datafields: [],
             columns: [],
             emunList: {} // gridproperty.emunlist[field]=[];
             ,displayFields:[]
         },
         yx: {
             datafields: [],
             columns: [],
             emunList: {} // gridproperty.emunlist[field]=[];
             ,displayFields:[]
         },
         yk: {
             datafields: [],
             columns: [],
             emunList: {} // gridproperty.emunlist[field]=[];
             ,displayFields:[]
         },
         yt: {
             datafields: [],
             columns: [],
             emunList: {} // gridproperty.emunlist[field]=[];
             ,displayFields:[]
         }

     };
     // 初始话工具栏按钮
     function initToolBar() {
         var measureAddDlg = initMeasureAddDlg();

         var toolAction = {
             add: function() {
                 var index = $('#measureTabs').jqxTabs('val');
                 var _datatype = index + 1;
                 var table = $("#measure_" + measureType[index]);
                 //
                 measureAddDlg.show(function(dlg) {

                     if (dlg.beginAddr != '') {
                         var rows = table.jqxGrid('getrows');
                         var result = "";
                         var DataIds = dlg.DataIds;

                         var rowlength = rows.length
                         var alreadyAdded = [];
                         for (var i = 0; i < rowlength; i++) {
                             var row = rows[i];
                             $.each(DataIds, function(index, id) {
                                 if (row.DataId == id) {
                                     alreadyAdded.push(id);

                                 }
                             });
                         }
                         if (alreadyAdded.length > 0) {
                             $.config.alertDlg("数据编号【 " + alreadyAdded.join('|') + " 】已经存在了！");
                             return;
                         }
                         dlg.jqxWindow("close");

                         // 多行缓存
                         var rows = new Array();

                         $.each(DataIds, function(index, id) {
                             // 赋值多行数据
                             // 对于数字列，默认都添加0，当复制数据的时候，如果源为非数字，会自动填写0.

                             rows.push({
                                 "ProcName": gPageParam.processPage.processName,
                                 "LinkNo": 0,
                                 "DataType": _datatype,
                                 "ProAddr": 0,

                                 "DataDesc": '新的数据项',
                                 "DataId": id,
                                 "Coe": 0,
                                 "Offset": 0,
                                 "FuncCode": 0,
                                 "DataStyle": 0,
                                 "ByteOrder": 0,
                                 "ChangeThreshold": 0,
                                 "GroupName": "", // OPC才有该项
                                 "ItemName": "" // 自定义item的名称
                             });

                             if (!table.data("rowData")) {
                                 table.data("rowData", {});
                             }
                             var items = table.data("rowData");
                             var item = items[id];
                             // 如果之前有对改时间的删除项，则修改为更新项。
                             if (item) {
                                 item.handle = 'update';
                             } else {
                                 // 否则，新建插入项
                                 item = {};
                                 item.handle = 'insert';
                             }
                             item.val = {
                                 "ProcName": gPageParam.processPage.processName,

                                 "DataType": _datatype,


                                 "DataDesc": '新的数据项',

                             };

                             items[id] = item;
                             table.data("rowData", items);
                         });
                         // 直接添加多行
                         var commit = table.jqxGrid('addrow', null, rows);

                     } else {
                         $.config.alertDlg("起始地址不能为空！")
                     }
                 });


             },
             delete: function() {
                 // 表格提供的多选存在选择多列，这里只取第一个的列【field】作为，被选择列，其他列将被忽视。
                 // 避免操作多列，对不必要的列进行了错误的操作。
                 // 设置为 'singlecell', 'multiplecells' or
                 // 'multiplecellsextended' 需要使用getselectedcell 方法

                 // 删除的时候，为什么至删除了备选择的奇数行。
                 var index = $('#measureTabs').jqxTabs('val');
                 var table = $("#measure_" + measureType[index]);
                 var cells = table.jqxGrid('getselectedcells');
                 var field = '';
                 if (cells[0]) {
                     field = cells[0].datafield;
                 }
                 var rowIDs = new Array();
                 for (var i = 0; i < cells.length; i++) {
                     var cell = cells[i];

                     var selectedrowindex = cell.rowindex;
                     // var selectedrowindex =
                     // table.jqxGrid('getselectedrowindex');
                     var rowscount = table.jqxGrid('getdatainformation').rowscount;
                     if (selectedrowindex >= 0 && selectedrowindex < rowscount && field == cell.datafield) {
                         var id = table.jqxGrid('getrowid', selectedrowindex);

                         rowIDs.push(id);
                         // 获取当前选择的row，对row的数据操作的时候会用到
                         var row = table.jqxGrid('getrowdatabyid', id);
                         // alert(JSON.stringify(row));

                         if (!table.data("rowData")) {
                             table.data("rowData", {});
                         }
                         var items = table.data("rowData");
                         var item = items[row.DataId]
                         if (item) {
                             // 更新的，标识为删除。
                             // 添加的，直接删除
                             if (item.handle == 'update') {
                                 item.handle = 'delete';
                             } else {
                                 delete items[row.DataId];

                             }
                         } else {
                             // 没有该项，添加，并标识为删除
                             item = {};
                             item.handle = 'delete';
                             items[row.DataId] = item;
                         }
                         table.data("rowData", items);
                         console.dir(row.DataId);
                     }
                 }
                 // 批量删除
                 var commit = table.jqxGrid('deleterow', rowIDs);
                 // 删除之后，由于选择项是按照rowid的，删除前面的row后面的会自动上移，还是处于选择状态。
                 table.jqxGrid('clearselection');
             },
             filter: function() {
                 var index = $('#measureTabs').jqxTabs('val');
                 var table = $("#measure_" + measureType[index]);

             },
             // 与之前的合并，不需要批量添加了。
             add_batch: function() {



             },
             add_sys: function() {
                 // 添加系统量测到规约采集量测表中，查询的时候，排除规约表中已经存在的点。
                 // 每次打开量测选择量测对话框，都需要重新查询一次。避免重复添加同一个GID的数据点。
                 // $("#measure_sys_dlg").load("measure_sys_dlg.html",
                 // function() {
                 // $.config.alertDlg("加载完成！");
                 // });

                 function getSysMeasure(dlg) {

                     var index = $('#measureTabs').jqxTabs('val');
                     var table = $("#measure_" + measureType[index]);
                     // 直接添加多行
                     var commit = table.jqxGrid('addrow', null, dlg.items);

                     dlg.jqxWindow("close");

                 }

                 measureSysDlg.show(getSysMeasure);

             }
         };

         $("#toolbar").jqxButtonGroup({
             theme: theme,
             mode: 'default'
         }).on('buttonclick', function(event) {
             var clickedButton = event.args.button;
             toolAction[clickedButton[0].id]();
             // $("#eventsLog").text("Clicked: " + clickedButton[0].id);
         });


     }
     // 初始化 右键菜单，单个选择单元格的右键复制，多个选择，只赋值第一个单元格的数据
     // 多个选择单元格的选择粘贴功能。
     //
     function initMeasureContextMenu() {
         // create context menu
         var contextMenu = $("#measure_menu").jqxMenu({
             width: 100,
             height: 90,
             theme: theme,
             autoOpenPopup: false,
             mode: 'popup'
         }).on('itemclick', function(event) {
             var target = $(event.target);
             // 通过item-value，路由处理菜单点击事件
             switch (target.attr("item-value")) {
                 case "copy":
                     {
                         var index = $('#measureTabs').jqxTabs('val');
                         var table = $("#measure_" + measureType[index]);

                         var index = $('#measureTabs').jqxTabs('val');
                         var table = $("#measure_" + measureType[index]);
                         var cells = table.jqxGrid('getselectedcells');
                         var field = '';
                         if (cells[0]) {
                             // 由于设置了 进程名称和数据类型隐藏属性，所以在获取当前选择列的时候会获取到该列。
                             // 通过查看js调试信息，获取一下信息代替直接的datafield。
                             field = cells[0].owner._clickedcolumn || cells[0].datafield;
                             // 获取选择的左上角第一个单元格的数据，作为备粘贴的数据
                             var value = table.jqxGrid('getcellvalue', cells[0].rowindex, field);
                             var text = $(this).data('clipBord', value);
                             console.dir('copy=' + value);
                             // alert(cells[0].rowindex + '==' + field + '=='
                             // + value);
                         } else {
                             // console.dir('select'+cells.length);
                             var value = $(this).data('clipBord_tmp');
                             var text = $(this).data('clipBord', value);
                             // alert(value);
                         }

                     }
                     break;
                 case "past":
                     {

                         var index = $('#measureTabs').jqxTabs('val');
                         var table = $("#measure_" + measureType[index]);
                         // 获取模拟剪贴板的数据
                         var text = $(this).data('clipBord');
                         if (isNaN(text))
                             text = parseFloat(text);
                         if (!text) {
                             $.config.alertDlg("请先复制，再粘贴！")
                             return;
                         }
                         var index = $('#measureTabs').jqxTabs('val');
                         var table = $("#measure_" + measureType[index]);
                         var cells = table.jqxGrid('getselectedcells');
                         var field = '';
                         if (cells[0]) {
                             // 由于设置了 进程名称和数据类型隐藏属性，所以在获取当前选择列的时候会获取到该列。
                             // 通过查看js调试信息，获取一下信息代替直接的datafield。
                             field = cells[0].owner._clickedcolumn || cells[0].datafield;
                             // 数据全局ID不允许编辑，值能够添加，删除
                             if (field == 'DataId') {

                                 return;
                             }

                         } else {
                             $.config.alertDlg("请选择需要批量粘贴的单元格！")
                         }
                         var rowIDs = new Array();
                         for (var i = 0; i < cells.length; i++) {
                             var cell = cells[i];

                             var selectedrowindex = cell.rowindex;
                             // var selectedrowindex =
                             // table.jqxGrid('getselectedrowindex');
                             // var rowscount =
                             // table.jqxGrid('getdatainformation').rowscount;//&&
                             // field == cell.datafield
                             var rowscount = table.jqxGrid('getrows').length;
                             // if (selectedrowindex >= 0 && selectedrowindex
                             // < rowscount) {
                             var id = table.jqxGrid('getrowid', selectedrowindex);
                             table.jqxGrid('setcellvalue', id, field, text);

                             // }
                         }
                     }
                     break;

                 case "prompt":
                     {


                         function setval(dlg) {
                             var index = $('#measureTabs').jqxTabs('val');
                             var table = $("#measure_" + measureType[index]);
                             var cells = table.jqxGrid('getselectedcells');
                             var field = '';
                             if (cells[0]) {
                                 // 由于设置了 进程名称和数据类型隐藏属性，所以在获取当前选择列的时候会获取到该列。
                                 // 通过查看js调试信息，获取一下信息代替直接的datafield。
                                 field = cells[0].owner._clickedcolumn || cells[0].datafield;
                                 // 数据全局ID不允许编辑，值能够添加，删除
                                 if (field == 'DataId') {

                                     return;
                                 }

                             } else {
                                 $.config.alertDlg("请选择需要批量粘贴的单元格！")
                             }
                             var rowIDs = new Array();
                             for (var i = 0; i < cells.length; i++) {
                                 var cell = cells[i];

                                 var selectedrowindex = cell.rowindex;
                                 // var selectedrowindex =
                                 // table.jqxGrid('getselectedrowindex');
                                 // var rowscount =
                                 // table.jqxGrid('getdatainformation').rowscount;//&&
                                 // field == cell.datafield
                                 var rowscount = table.jqxGrid('getrows').length;
                                 // if (selectedrowindex >= 0 &&
                                 // selectedrowindex < rowscount) {
                                 var id = table.jqxGrid('getrowid', selectedrowindex);
                                 table.jqxGrid('setcellvalue', id, field, dlg.value);

                                 // }
                             }

                         }
                         // $.config.alertDlg("fffffffffffff");
                         $.config.prompt(setval, '设置值：');


                     }
             };

         });

         return contextMenu;
     }
     var measureContextMenu = initMeasureContextMenu();
     // ///////////////////////////////////////////////////////////////////
     // 加载配置文件，并形成界面
     // measureType 通道或是驱动
     // driverType 具体通道或是驱动的类型
     // ///////////////////////////////////////////////////////////////////
     function initPropertyGrid(datatype, driverType) {

         var source = {
             datatype: "xml",
             datafields: [{
                 name: 'Desc',
                 map: 'm\\:properties>d\\:Desc'
             }, {
                 name: 'Field',
                 map: 'm\\:properties>d\\:Field'
             }, {
                 name: 'DefaultValue',
                 map: 'm\\:properties>d\\:DefaultValue'
             }, {
                 name: 'DataType',
                 map: 'm\\:properties>d\\:DataType'
             }, {
                 name: 'Enum',
                 map: 'm\\:properties>d\\:EnumData' // 在低版本中，xml的项必须存在，且不能为空，高版本中可以不存在，且能为空，所以在没有枚举量的xml项中补填N作为占位
             }],
             root: "content",
             // record : "content",
             id: 'm\\:properties>d\\:Field',
             url: "table_xml/Measure/" + driverType + "/ProtocolParam_" + measureType[datatype] + ".xml"
         };
         // 加载配置文件
         var dataAdapter = new $.jqx.dataAdapter(source, {
             autoBind: true,
             loadComplete: function() {
                 // get data records.
                 var records = dataAdapter.records;
                 var length = records.length;
                 for (var i = 0; i < length; i++) {
                     var record = records[i];
                     var fields = {};
                     fields["name"] = record.Field;

                     gridProperty[measureType].datafields.push(fields);
                     gridProperty[measureType].displayFields.push(record.Field);
                     var column = {};
                     column["datafield"] = record.Field;
                     column["text"] = record.Desc;

                     // 根据 配置项的多少决定是否设置宽度
                     var width = $("#measureTabs").width();
                     if ((length * 100) > width)
                         column["width"] = 100;
                     // 数据全局id禁止编辑
                     if (record.Field == 'DataId') {
                         column["editable"] = false;
                         column["cellvaluechanging"] = function(row, datafield, columntype, oldvalue, newvalue) {
                             newvalue = oldvalue;
                             return oldvalue;
                         }
                         column['disable'] = true;

                     }
                     // alert(record.DataType);
                     if (record.DataType.indexOf("Bool") > -1) {
                         column["columntype"] = 'checkbox';
                     } else {
                         if (record.DataType.indexOf("Enum") > -1) // 直接判断==
                         // 也可以，为了防止字符串中的空格
                         {

                             column["columntype"] = 'dropdownlist';
                             try {
                                 gridProperty[measureType].emunList[record.Field] = [];
                                 // eval('(' + record.Enum + ')')
                                 // 字符串转换json的另一种方法
                                 var enumval = jQuery.parseJSON(record.Enum); // 将枚举类型的json字符串转换为json对象，

                                 // $(enumval).each(function(feild,text){
                                 $.each(enumval, function(value, text) { // 遍历json对象，形成dropdownlist需要的source对象
                                     var item = {};
                                     item["value"] = value;
                                     item["text"] = text;


                                     gridProperty[measureType].emunList[record.Field].push(item);


                                 });
                             } catch (e) {
                                 console.dir(record.Field + " comes error!");

                             }
                             column["createeditor"] = function(row, cellvalue, editor, celltext, cellwidth, cellheight) {
                                 // assign a new data source to the
                                 // dropdownlist.
                                 // console.dir(this.datafield +"==" +
                                 // cellvalue);
                                 editor.jqxDropDownList({
                                     source: gridProperty[measureType].emunList[this.datafield],
                                     placeHolder: "",
                                     autoDropDownHeight: true,
                                     displayMember: "text",
                                     valueMember: "value",
                                     theme: theme
                                 });

                             };

                             column["initEditor"] = function(row, cellvalue, editor, celltext, width, height) {
                                 // set the editor's current value. The
                                 // callback is called each time the editor
                                 // is displayed.
                                 editor.jqxDropDownList({
                                     width: width,
                                     height: height
                                 });

                                 editor.val(cellvalue);
                             };


                             column["getEditorValue"] = function(row, cellvalue, editor) {
                                 // return the editor's value.
                                 console.dir(cellvalue);
                                 return editor.val();
                             };


                         }
                         // 除了 bool 和 enum其他所有的都需要设置 可编辑，和显示渲染
                         column["cellvaluechanging"] = function(row, column, columntype, oldvalue, newvalue) {
                             // return the old value, if the new value is
                             // empty.
                             if (newvalue == "") return oldvalue;
                         };

                         column["cellbeginedit"] = function(row, datafield, columntype) {
                             // 获取row对应的datafield的flag的ckeckbox，如果是1，返回true，如果是0，返回false
                             // 如果量测启用，前面的所有项才可编辑
                             // 这里只有遥测会有这样的配置约束，所以在这里直接填写了遥测dom的div对应的id。在这里取dom的owner的id。不太好弄
                             // 波动 Fluc --对应单元格返回false


                             var editableFlag = true;
                             if ((datafield == "PortName2") || (datafield == "Band2") || (datafield == "Parity2") || (datafield == "DataBits2") || (datafield == "StopBits2")) {
                                 editableFlag = $("#" + measureType).jqxGrid('getcellvalue', row, "DblChannel");

                             }

                             return editableFlag;

                         } // end cellbeginedit
                         // checkbox 相关的单元格，如果checkbox没有备选中，不允许编辑
                         column["cellsrenderer"] = function(row, datafield, value, defaultHtml, columnproperties) {
                             // 根据 column->feild column 判断当前列。
                             var editableFlag = true;
                             // if ((datafield == "PortName2") || (datafield
                             // == "Band2") || (datafield == "Parity2") ||
                             // (datafield == "DataBits2") || (datafield ==
                             // "StopBits2")) {
                             if (columnproperties.columntype == "dropdownlist") {

                                 $.each(gridProperty[measureType].emunList[datafield], function(n, val) {
                                     if (val.value == value)
                                         defaultHtml = val.text;
                                 });
                             }
                             // 设置不可编辑的颜色
                             if (editableFlag == false) {
                                 var element = $(defaultHtml);
                                 element.css('color', '#131313');
                                 return element[0].outerHTML;
                             }

                             return defaultHtml;

                         } // end cellsrenderer
                     }
                     gridProperty[measureType[datatype]].columns.push(column);
                 }

                 // ================== 表格初始话数据加载完成了之后才初始化
                 // tab，然后在tab的init中初始化表格
                 return crateGird(datatype, driverType);
             }
         });

         // ////////////////////////////////////////////////////////////////
         // 通过配置文件加载的数据项，形成数据表格框架，并加根据 driverType加载表格数据
         //
         // ////////////////////////////////////////////////////////////////
         function crateGird(datatype, driverType) {

             var source = {
                 datatype: "csv",
                 datafields: gridProperty[measureType[datatype]].datafields,
                 data: {
                     measureType: datatype,
                     procName: gPageParam.processPage.processName,
                     fields: gridProperty[measureType[datatype]].displayFields.join(",")
                 },
                 url: "config/ProtocolParam!getList"
             };

             var dataAdapter = new $.jqx.dataAdapter(source, {

                 loadError: function(xhr, status, error) {
                     alert('Error loading "' + source.url + '" : ' + error);
                 }
             });


             var table = $("#measure_" + measureType[datatype]).jqxGrid({
                 width: '99.5%',
                 height: '99.5%',
                 theme: theme,
                 columnsresize: true, // 设置可调整columns大小
                 editable: true,
                 altrows: true,
                 filterable: true,
                 enablebrowserselection: false, // 禁止浏览器文本选择功能
                 handlekeyboardnavigation: handleKeys,
                 selectionmode: 'multiplecellsadvanced', // 'multiplecellsadvanced',
                 // //'multiplecellsextended'
                 // , //设置选择方式
                 source: dataAdapter,
                 ready: function() {

                     // table.jqxGrid('hidecolumn', 'ProcName');
                     // table.jqxGrid('hidecolumn', 'DataType');
                 },
                 // selectionmode : 'singlecell', //设置选择方式
                 columns: gridProperty[measureType[datatype]].columns
             }).on('cellvaluechanged', function(event) {

                 var field = args.datafield;
                 var rowindex = args.rowindex;
                 var value = args.newvalue;
                 if (!value)
                     return;

                 var row = table.jqxGrid('getrowdata', rowindex);
                 var oldvalue = args.oldvalue;
                 // 设置变化值到缓存中
                 if (!$(this).data("rowData"))
                     $(this).data("rowData", {});
                 var rowData = $(this).data("rowData");
                 var item = rowData[row.DataId];
                 if (item) {
                     // 更新的，直接更新数据，更新对应字段的数据。
                     // 添加的 ，不更新操作，直接更新数据。
                     // 删除的，提示删除一条已经备删除的记录。
                     if (item.handle == 'delete') {
                         console.dir("错误，更新一条需要删除的记录");
                     } else {
                         item.val[field] = value;
                     }
                 } else {
                     // 没有就创建一条更新的数据
                     item = {};
                     item.handle = 'update';
                     item.val = {};
                     item.val[field] = value;
                 }

                 rowData[row.DataId] = item; // 更新到rowdata

                 $(this).data("rowData", rowData);


                 // console.dir(column + '==' + row + "===" + value +
                 // $(this).attr('id'));

             }).on('cellclick', function(event) {
                 if (event.args.rightclick) {
                     var value = event.args.value;
                     var column = event.args.column;
                     var rowindex = event.args.rowindex;
                     var columnindex = event.args.columnindex;
                     // 不允许编辑的列，没有菜单项
                     if (column.editable == false)
                         return;

                     // 如果没有选择单元格，以当前鼠标点击的单元格作为复制源
                     measureContextMenu.data('clipBord_tmp', value);
                     // 目前设计，只针对单个源-》多个目标的复制粘贴，如果是多个源到多个目标


                     var scrollTop = $(window).scrollTop();
                     var scrollLeft = $(window).scrollLeft();
                     measureContextMenu.jqxMenu('open', parseInt(event.args.originalEvent.clientX) + 5 + scrollLeft, parseInt(event.args.originalEvent.clientY) + 5 + scrollTop);

                     return false;
                 }
             }).on('cellselect', function(event) {
                 var columnheader = $(this).jqxGrid('getcolumn', event.args.datafield).text;
                 var rowindex = event.args.rowindex;
                 // console.dir('cellselect' + columnheader);
             });
             // //////////////////////////////////////////////////////////////////////////
             //
             // 通过键盘粘贴数据，需要再验证，firefox和ie对这个脚本的支持不一样。
             // //////////////////////////////////////////////////////////////////////////
             function handleKeys(event) {
                 // 对IE支持键盘快捷键的复制粘贴，需要屏蔽
                 var key = event.charCode ? event.charCode : event.keyCode ? event.keyCode : 0;
                 if (key == 13) {
                     alert('Pressed Enter Key.');
                     return true;
                 } else if (key == 27) {
                     alert('Pressed Esc Key.');
                     alert(table.attr('id'));
                     return true;
                 } else if (event.ctrlKey && key == 86) {
                     // 取消对
                     var cells = table.jqxGrid('getselectedcells');
                     var field = '';
                     if (cells[0]) {
                         // 由于设置了 进程名称和数据类型隐藏属性，所以在获取当前选择列的时候会获取到该列。
                         // 通过查看js调试信息，获取一下信息代替直接的datafield。
                         field = cells[0].owner._clickedcolumn || cells[0].datafield;


                     } else {
                         $.config.alertDlg("请选择需要批量粘贴的单元格！")
                     }
                     var rowIDs = new Array();
                     for (var i = 0; i < cells.length; i++) {
                         var cell = cells[i];

                         var selectedrowindex = cell.rowindex;
                         // var selectedrowindex =
                         // table.jqxGrid('getselectedrowindex');
                         // var rowscount =
                         // table.jqxGrid('getdatainformation').rowscount;//&&
                         // field == cell.datafield
                         var rowscount = table.jqxGrid('getrows').length;
                         if (selectedrowindex >= 0 && selectedrowindex < rowscount) {
                             var id = table.jqxGrid('getrowid', selectedrowindex);

                         }
                     }


                     return false;
                 }

             }
             // table.on('rowselect', function (event)
             // {
             // var args = event.args;
             // var row = args.rowindex;
             // alert(row);
             // // driverGrid.jqxGrid('selectrow', row);

             // });
             console.dir("创建数据配置表成功!");

             // table.on('bindingcomplete', function(event) {
             // // alert("Binding is completed" );
             // table.jqxGrid('hidecolumn', 'ProcName');
             // table.jqxGrid('hidecolumn', 'DataType');
             // });
             return table;
         }

     }

     function initMeasureAddDlg() {

         var beginAddr = $("#begin_addr").jqxNumberInput({
             width: '95px',
             height: '22px',
             inputMode: 'simple',
             spinButtons: true
         });

         var measureCount = $("#measure_count").val(1).jqxNumberInput({
             width: '95px',
             height: '22px',
             inputMode: 'simple',
             spinButtons: true
         });


         function _call() {

         }
         // =====================================================================
         // 机组类型中添加机组对话框
         var measure_add_dlg = $('#measures_add_dlg').jqxWindow({

             height: 185,
             width: 195,
             resizable: false,
             isModal: true,
             modalOpacity: 0.3,
             theme: theme,
             autoOpen: false,
             okButton: $('#measures_add_dlg #ok'),
             cancelButton: $('#measures_add_dlg #cancel'),
             initContent: function() {
                 $('#measures_add_dlg #ok').jqxButton({
                     theme: theme,
                     width: '65px'
                 });
                 $('#measures_add_dlg #cancel').jqxButton({
                     theme: theme,
                     width: '65px'
                 });
                 $('#measures_add_dlg #ok').focus();


             }
         });
         $('#measures_add_dlg #ok').off().on("click", function(event) {
             // 获取当前的tree中的设备的select项的数据，返回并添加到驱动数据列表中，供参数配置
             var dataIds = [];
             var begin_addr = beginAddr.jqxNumberInput('val');
             var measure_count = measureCount.jqxNumberInput('val');
             for (var i = 0; i < measure_count; i++) {
                 dataIds.push(begin_addr + i);
             }
             measure_add_dlg.beginAddr = begin_addr;
             measure_add_dlg.DataIds = dataIds;
             _call(measure_add_dlg);

         });
         measure_add_dlg.show = function(callBack) {
             $(this).jqxWindow("open");
             _call = callBack
         }
         return measure_add_dlg;
     }
     // ////////////////////////////////////////////////////////////////////
     // ======================================
     // ===系统设备树，不是直接加载json数据，而是通过普通的ajax加载，将数据读取到全局缓存中。
     // ===每次点击对话框的时候都会读取数据库中的数据，将当前已经配置过的数据过滤调。避免重复加载的问题。
     // 每次打开对话的时候，通过ajax动态的请求当前那些设备数据还没有配置驱动程序。
     // ////////////////////////////////////////////////////////////////////
     function initEqpMeasureTree(list) {

         var source = {
             datatype: "json",
             datafields: [{
                 name: "name",
                 type: "string"
             }, {
                 name: "id",
                 type: "number"
             }, {
                 name: "children",
                 type: "array"
             }, {
                 name: "selectMeasure",
                 type: "object"
             }],
             hierarchy: {
                 root: "children"
             },
             // localData: treeGridData,
             url: "config/SystemTopology!getSysMeasureTree"
             id: "id"
         };

         var dataAdapter = new $.jqx.dataAdapter(source, {
             loadComplete: function() {

             }
         });
         // create jqxTreeGrid.

         var tree = $("#eqp_measure_tree").jqxTreeGrid({
                 source: dataAdapter,
                 altRows: true,
                 width: '240',
                 height: '500',
                 checkboxes: true,
                 theme: theme,

                 ready: function() {


                 },
                 columns: [{
                     text: "设备",
                     align: "center",
                     dataField: "name"
                     // , width: 250
                 }, {
                     text: "设备",
                     align: "center",
                     dataField: "selectMeasure",
                     hidden: true
                     // , width: 250
                 }]
             })
             .on('rowUnselect', function(event) {
                 // 获取当前list中的所有项，更新到treedata中

                 var args = event.args;
                 // row data.
                 var row = args.row;
                 // row key.
                 var key = args.key;
                 var items = list.jqxGrid('getrows'); // 获取当前表格的数据
                 console.dir(JSON.stringify(items));
                 // //===========对jqxgrid显示需要进行响应的数据处理
                 // var result = "";
                 // for (var i = 0; i < rows.length; i++) {
                 // var row = rows[i];
                 // if (typeof(rows[i]["measureFilter"]) == "object")
                 // //jqxgrid 加载数据的时候不能是object，所以存储数据的时候，转换为string

                 // {
                 // rows[i]["measureFilter"] =
                 // JSON.stringify(rows[i]["measureFilter"]); //将json的object
                 // 转换为string
                 // }
                 // //alert(rows[i]["measureisSelect"]);
                 // // result += row.measureName + " " + row.measureFilter +
                 // " " + row.measureisSelect + " " + row.id + "\n";
                 // }
                 // //==================== alert(result);
                 // //获取当前tab对应的表格所显示的数据，并更新到deviceMeasure中
                 // deviceMeasure[$(".tabs-item.select").attr("measureType")]
                 // = rows; //放入全局data当前选择的设备量测缓存中
                 // //deviceMeasure就是jqxTreeGrid中的数据，js中的数据是共享地址空间的。
                 $(this).jqxTreeGrid('setCellValue', key, 'selectMeasure', items);
                 // $(this).jqxTreeGrid('setCellValue', key, 'name', "asdf");
                 // $(this).jqxTreeGrid('endUpdate'); //及时更新treegrid

             }).on('rowSelect', function(event) {
                 // 获取当前tree的选择row的数据，更新到list列表中
                 var args = event.args;
                 // row data.
                 var row = args.row;
                 // row key.
                 var key = args.key;
                 // 获取当前选择的grid select-measure字段的值
                 var items = $(this).jqxTreeGrid('getCellValue', key, 'selectMeasure');
                 // //更新到量测可选列表中
                 // listdata = items;
                 list.update(items);
                 console.dir(JSON.stringify(items));
                 // updateDeviceDataList($(".tabs-item.select").attr("measureType"));

             });

         tree.update = function() {
             // source.localData=treeGridData;

             $(this).jqxTreeGrid('updateBoundData'); // 及时更新treegrid
         }

         return tree;
     }

     // ///////////////////////////////////////////////////////
     //
     // 初始化设备量测列表
     //
     function initEqpMeasureList() {
         var source = {
             datatype: "arry",
             datafields: [{
                 name: "name",
                 type: "string"
             }, {
                 name: "id",
                 type: "number"
             }, {
                 name: "select",
                 type: "bool"
             }],
             localdata: listdata,
             id: "id"
         };

         var dataAdapter = new $.jqx.dataAdapter(source, {
             loadComplete: function() {

             }
         });

         // =====================================================================
         var list = $("#eqp_measure_list").jqxGrid({
                 width: 240,
                 theme: theme,
                 source: dataAdapter,

                 selectionmode: 'checkbox',
                 height: 500,
                 theme: theme,
                 // ready: function() //设置被选择的项
                 // {

                 // },

                 columns: [{
                     text: "点号",
                     align: "center",
                     dataField: "id",
                     // width: '48%',
                     editable: false
                 }, {
                     text: "名称",
                     cellsAlign: "center",
                     align: "center",
                     dataField: "name",
                     width: '46%',
                 }]
                 // event.args 参数中如果有row
                 // 表示为但row操作，如果没有row表示对表格所有rows操作。由于unselect中对所有rows操作的时候得到的rowindex是不可用的，
                 // 因此采用对row的判断来操作表格中的数据的是否被选择的状态。
             }).on("rowselect", function(event) {

                 var rows = $(this).jqxGrid('getrows');

                 if (event.args.row) {
                     event.args.row["select"] = true;
                     $(this).jqxGrid('setcellvalue', event.args.rowindex, "select", true);

                 } else {
                     // 直接遍历rowindex
                     $(event.args.rowindex).each(function(index, value) {
                         rows[this]["select"] = true;
                         $(this).jqxGrid('setcellvalue', value, "select", true);

                     });
                 }


             }).on("rowunselect", function(event) {

                 var rows = $(this).jqxGrid('getrows');
                 if (event.args.row) {
                     event.args.row["select"] = false;
                     $(this).jqxGrid('setcellvalue', event.args.rowindex, "select", false);
                 } else {
                     // 直接遍历所有row，与使用event.args.orwindex同样的效果
                     for (var i = 0; i < rows.length; i++) {
                         rows[i]["select"] = false;
                         $(this).jqxGrid('setcellvalue', i, "select", false);
                     }
                 }

             })
             .on('bindingcomplete', function() {
                 // 数据更新成功的时候触发该事件
                 // alert('binding is completed');
             });
         // ////////////////////////////////////////////////////////////////////


         list.update = function(newdata) {

             source.localdata = newdata;
             $(this).jqxGrid('updatebounddata', 'cells');

             var rows = $(this).jqxGrid('getrows');
             // 获取上次表格中的数据
             // measureData[$(this).attr("measureType")] = rows;
             // var result = "";
             // 设置row的选择状态
             for (var i = 0; i < rows.length; i++) {
                 if (rows[i]["select"]) {
                     console.dir(i + "== true");
                     $(this).jqxGrid('selectrow', i);
                 } else {
                     console.dir(i + "== false");
                     $(this).jqxGrid('unselectrow', i);
                 }
             }
             // alert($(this).attr("id"));
             console.dir($(this).attr("id") + "list.update ");

         }
         return list;
     }

     // ======================================系统量测选择对话框
     function initMeasureSysDlg() {

         function _call() {

         }
         var list = initEqpMeasureList();

         var measureTree = initEqpMeasureTree(list);
         var measure_sys_dlg = $('#measure_sys_dlg').jqxWindow({

             height: 600,
             width: 500,
             resizable: false,
             isModal: true,
             modalOpacity: 0.3,
             theme: theme,
             autoOpen: false,
             // okButton: $('#mSelectOK'),
             cancelButton: $('#mSelectCancel'),
             initContent: function() {
                 $('#mSelectOK,#mSelectCancel').jqxButton({
                     theme: theme,
                     width: '65px'
                 });

                 $('#mSelectOK').focus();


             }
         });
         $('#measure_sys_dlg #mSelectOK').off().on("click", function(event) {
             // 通过触发当前备选择row的 unselect事件，更新当前选择的tree对应的量测选择结果到tree中
             var selection = measureTree.jqxTreeGrid('getSelection');
             if (selection[0])
                 measureTree.jqxTreeGrid('unselectRow', selection[0].uid);
             // 循环获取tree中的数据项
             var _rows = measureTree.jqxTreeGrid('getRows');
             // alert(JSON.stringify(_rows));
             var newRows = [];
             // 数据类型，根据tab的选择而定，一次为1-4 遥测 遥信 遥控 遥调
             var _datatype = $('#measureTabs').jqxTabs('val') + 1;
             // 当前选择的tab项
             var index = $('#measureTabs').jqxTabs('val');
             var table = $("#measure_" + measureType[index]);

             function traverseTree(rows) {

                 for (var i = 0; i < rows.length; i++) {
                     // 获取被选择的leaf
                     if (rows[i].checked) {
                         // 解析数据项的的select-measure项的数据到数据列
                         $(rows[i]["selectMeasure"]).each(function() {

                             // 只添加被选择的项
                             if (this.select) {
                                 newRows.push({
                                     "ProcName": gPageParam.processPage.processName,
                                     "LinkNo": 0,
                                     "DataType": _datatype,
                                     "ProAddr": 0,
                                     "DataDesc": rows[i]["name"] + '-' + this.name,
                                     "DataId": this.id,
                                     "Coe": 0,
                                     "Offset": 0,
                                     "FuncCode": 0,
                                     "DataStyle": 0,
                                     "ByteOrder": 0,
                                     "ChangeThreshold": 0,
                                     "GroupName": "", // OPC才有该项
                                     "ItemName": "" // 自定义item的名称
                                 });
                                 // ===============================
                                 if (!table.data("rowData")) {
                                     table.data("rowData", {});
                                 }
                                 var items = table.data("rowData");
                                 var item = items[this.id];
                                 // 如果之前有对改时间的删除项，则修改为更新项。
                                 if (item) {
                                     item.handle = 'update';
                                 } else {
                                     // 否则，新建插入项
                                     item = {};
                                     item.handle = 'insert';
                                 }
                                 item.val = {
                                     "ProcName": gPageParam.processPage.processName,

                                     "DataType": _datatype,

                                     "DataDesc": rows[i]["name"] + '-' + this.name,

                                 };

                                 items[this.id] = item;
                                 table.data("rowData", items);

                             }

                         });



                     }
                     // //回调读取所有的子节点
                     if (rows[i].records) {
                         traverseTree(rows[i].records);
                     }
                 }


             }

             traverseTree(_rows);

             measure_sys_dlg.items = newRows;
             _call(measure_sys_dlg);

         });
         measure_sys_dlg.show = function(callBack) {
             // ajax获取设备量测数据，获取失败给予提示
             var dlg = $(this);
             // 清空list中的项
             list.update(new Array());
             // 重新加载tree中的数据，每次重新获取未配置采集程序的系统数据项
             measureTree.update();
             // 展开所有的属性节点，好像没有效果，需要进一步验证。
             // var rows = measureTree.jqxTreeGrid('getRows');
             // var rowsData = "";
             // var traverseTree = function(rows) {
             // for (var i = 0; i < rows.length; i++) {
             // measureTree.jqxTreeGrid('expandRow', rows[i].uid);
             // // rowsData += rows[i].uid + " " + rows[i].name + "\n";
             // if (rows[i].records) {
             // traverseTree(rows[i].records);
             // }
             // }
             // };
             // traverseTree(rows);

             _call = callBack
             dlg.jqxWindow("open");
         }
         return measure_sys_dlg;
     }
 });